// $ANTLR : "anasint.g" -> "Anasint.java"$

import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;

public class Anasint extends antlr.LLkParser       implements AnasintTokenTypes
 {

protected Anasint(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
}

public Anasint(TokenBuffer tokenBuf) {
  this(tokenBuf,2);
}

protected Anasint(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
}

public Anasint(TokenStream lexer) {
  this(lexer,2);
}

public Anasint(ParserSharedInputState state) {
  super(state,2);
  tokenNames = _tokenNames;
}

	public final void programa() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			declaraciones();
			cuerpo_programa();
			match(Token.EOF_TYPE);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void declaraciones() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case CONST:
			{
				constantes();
				break;
			}
			case TYPE:
			case VAR:
			case BEGIN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case TYPE:
			{
				tipos_compuestos();
				break;
			}
			case VAR:
			case BEGIN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case VAR:
			{
				varfuns();
				break;
			}
			case BEGIN:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_1);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void cuerpo_programa() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(BEGIN);
			{
			_loop1630:
			do {
				if ((_tokenSet_2.member(LA(1)))) {
					decin();
				}
				else {
					break _loop1630;
				}
				
			} while (true);
			}
			match(END);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void constantes() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(CONST);
			{
			int _cnt1590=0;
			_loop1590:
			do {
				if ((LA(1)==IDENT)) {
					constante();
				}
				else {
					if ( _cnt1590>=1 ) { break _loop1590; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1590++;
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_3);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void tipos_compuestos() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(TYPE);
			{
			int _cnt1594=0;
			_loop1594:
			do {
				if ((LA(1)==IDENT)) {
					tipo_compuesto();
				}
				else {
					if ( _cnt1594>=1 ) { break _loop1594; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1594++;
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_4);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void varfuns() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(VAR);
			{
			int _cnt1602=0;
			_loop1602:
			do {
				if ((_tokenSet_5.member(LA(1)))) {
					varfun();
				}
				else {
					if ( _cnt1602>=1 ) { break _loop1602; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1602++;
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_1);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void constante() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(IDENT);
			match(IGUAL);
			expresion();
			match(PUNTO_Y_COMA);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion_nivel_1();
			{
			_loop1662:
			do {
				if ((LA(1)==OR)) {
					match(OR);
					expresion_nivel_1();
				}
				else {
					break _loop1662;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_7);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void tipo_compuesto() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(IDENT);
			match(IGUAL);
			match(REGISTRO);
			campos();
			match(END);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_8);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void campos() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			{
			int _cnt1598=0;
			_loop1598:
			do {
				if ((_tokenSet_9.member(LA(1)))) {
					campo();
				}
				else {
					if ( _cnt1598>=1 ) { break _loop1598; } else {throw new NoViableAltException(LT(1), getFilename());}
				}
				
				_cnt1598++;
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_10);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void campo() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			tipo();
			match(IDENT);
			match(PUNTO_Y_COMA);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_11);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void tipo() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case MENOS:
			case LIT_CAR:
			case ENTERO:
			case REAL:
			case BOOLEANO:
			case CARACTER:
			case RANGO_NUM:
			{
				tipo_predefinido_simple();
				break;
			}
			case CADENA:
			case ARRAY:
			{
				tipo_predefinido_compuesto();
				break;
			}
			case IDENT:
			{
				match(IDENT);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_12);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void varfun() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case IDENT:
			case MENOS:
			case LIT_CAR:
			case ENTERO:
			case REAL:
			case BOOLEANO:
			case CARACTER:
			case RANGO_NUM:
			case CADENA:
			case ARRAY:
			{
				variable_global();
				break;
			}
			case FUNCION:
			{
				dec_funcion();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_13);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void variable_global() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			tipo();
			lista_nombres_variables_locales();
			match(PUNTO_Y_COMA);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_13);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void dec_funcion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			prototipo_funcion();
			definicion_funcion();
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_13);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void lista_nombres_variables_locales() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			nombre_variable_local();
			{
			_loop1626:
			do {
				if ((LA(1)==COMA)) {
					match(COMA);
					nombre_variable_local();
				}
				else {
					break _loop1626;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_14);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void lista_nombres_variables_globales() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			nombre_variable_global();
			{
			_loop1607:
			do {
				if ((LA(1)==COMA)) {
					match(COMA);
					nombre_variable_global();
				}
				else {
					break _loop1607;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void nombre_variable_global() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(IDENT);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_15);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void prototipo_funcion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(FUNCION);
			{
			if ((_tokenSet_9.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
				tipo();
			}
			else if ((LA(1)==IDENT) && (LA(2)==PARENTESIS_ABIERTO)) {
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
			}
			match(IDENT);
			match(PARENTESIS_ABIERTO);
			declaracion_parametros();
			match(PARENTESIS_CERRADO);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void definicion_funcion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			decins();
			match(END);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_13);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void declaracion_parametros() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case IDENT:
			case MENOS:
			case LIT_CAR:
			case ENTERO:
			case REAL:
			case BOOLEANO:
			case CARACTER:
			case RANGO_NUM:
			case CADENA:
			case ARRAY:
			{
				declaracion_parametro();
				{
				_loop1614:
				do {
					if ((LA(1)==COMA)) {
						match(COMA);
						declaracion_parametro();
					}
					else {
						break _loop1614;
					}
					
				} while (true);
				}
				break;
			}
			case PARENTESIS_CERRADO:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_18);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void declaracion_parametro() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			tipo();
			match(IDENT);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_19);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void decins() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			{
			_loop1619:
			do {
				if ((_tokenSet_2.member(LA(1)))) {
					decin();
				}
				else {
					break _loop1619;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_10);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void decin() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			boolean synPredMatched1622 = false;
			if (((_tokenSet_9.member(LA(1))) && (_tokenSet_16.member(LA(2))))) {
				int _m1622 = mark();
				synPredMatched1622 = true;
				inputState.guessing++;
				try {
					{
					tipo();
					lista_nombres_variables_locales();
					}
				}
				catch (RecognitionException pe) {
					synPredMatched1622 = false;
				}
				rewind(_m1622);
inputState.guessing--;
			}
			if ( synPredMatched1622 ) {
				declaracion_variables_locales();
			}
			else if ((_tokenSet_20.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
				instruccion();
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void declaracion_variables_locales() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			tipo();
			lista_nombres_variables_locales();
			match(PUNTO_Y_COMA);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void instruccion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case SI:
			case MIENTRAS:
			case DESDE:
			{
				instruccion_compuesta();
				break;
			}
			case IDENT:
			case PARENTESIS_ABIERTO:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				instruccion_simple();
				match(PUNTO_Y_COMA);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void nombre_variable_local() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(IDENT);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_22);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void instruccion_compuesta() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case SI:
			{
				condicion();
				break;
			}
			case MIENTRAS:
			case DESDE:
			{
				iteracion();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void instruccion_simple() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			boolean synPredMatched1634 = false;
			if (((_tokenSet_23.member(LA(1))) && (_tokenSet_21.member(LA(2))))) {
				int _m1634 = mark();
				synPredMatched1634 = true;
				inputState.guessing++;
				try {
					{
					expresion();
					match(ASIGNACION);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched1634 = false;
				}
				rewind(_m1634);
inputState.guessing--;
			}
			if ( synPredMatched1634 ) {
				asignacion();
			}
			else if ((LA(1)==IDENT) && (LA(2)==PARENTESIS_ABIERTO||LA(2)==CORCHETE_ABIERTO||LA(2)==PUNTO)) {
				llamada_metodo();
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_14);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void asignacion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion();
			match(ASIGNACION);
			expresion();
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_14);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void llamada_metodo() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			acceso();
			match(PARENTESIS_ABIERTO);
			lista_expresiones();
			match(PARENTESIS_CERRADO);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_24);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void condicion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(SI);
			expresion();
			{
			switch ( LA(1)) {
			case IDENT:
			case PARENTESIS_ABIERTO:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				{
				instruccion_simple();
				match(PUNTO_Y_COMA);
				}
				break;
			}
			case BEGIN:
			{
				bloque();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case SINO:
			{
				match(SINO);
				{
				switch ( LA(1)) {
				case IDENT:
				case PARENTESIS_ABIERTO:
				case NOT:
				case MENOS:
				case LIT_ENTERO:
				case LIT_REAL:
				case LIT_CAR:
				case CIERTO:
				case FALSO:
				case FRASE:
				{
					{
					instruccion_simple();
					match(PUNTO_Y_COMA);
					}
					break;
				}
				case BEGIN:
				{
					bloque();
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				break;
			}
			case IDENT:
			case END:
			case PARENTESIS_ABIERTO:
			case SI:
			case MIENTRAS:
			case DESDE:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			case ENTERO:
			case REAL:
			case BOOLEANO:
			case CARACTER:
			case RANGO_NUM:
			case CADENA:
			case ARRAY:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void iteracion() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case MIENTRAS:
			{
				mientras();
				break;
			}
			case DESDE:
			{
				acotado();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void acceso() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			if ((LA(1)==IDENT) && (LA(2)==CORCHETE_ABIERTO)) {
				acceso_simple();
				match(CORCHETE_ABIERTO);
				lista_expresiones_nv();
				match(CORCHETE_CERRADO);
				{
				int _cnt1688=0;
				_loop1688:
				do {
					if ((LA(1)==PUNTO)) {
						match(PUNTO);
						acceso_simple();
					}
					else {
						if ( _cnt1688>=1 ) { break _loop1688; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt1688++;
				} while (true);
				}
			}
			else if ((LA(1)==IDENT) && (LA(2)==PUNTO)) {
				acceso_simple();
				{
				int _cnt1690=0;
				_loop1690:
				do {
					if ((LA(1)==PUNTO)) {
						match(PUNTO);
						acceso_simple();
					}
					else {
						if ( _cnt1690>=1 ) { break _loop1690; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt1690++;
				} while (true);
				}
			}
			else if ((LA(1)==IDENT) && (_tokenSet_24.member(LA(2)))) {
				acceso_simple();
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_24);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void lista_expresiones() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case IDENT:
			case PARENTESIS_ABIERTO:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				expresion();
				{
				_loop1640:
				do {
					if ((LA(1)==COMA)) {
						match(COMA);
						expresion();
					}
					else {
						break _loop1640;
					}
					
				} while (true);
				}
				break;
			}
			case PARENTESIS_CERRADO:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_18);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void bloque() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(BEGIN);
			{
			_loop1659:
			do {
				if ((_tokenSet_23.member(LA(1)))) {
					instruccion_simple();
					match(PUNTO_Y_COMA);
				}
				else {
					break _loop1659;
				}
				
			} while (true);
			}
			match(END);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_25);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void mientras() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(MIENTRAS);
			expresion();
			match(HACER);
			{
			switch ( LA(1)) {
			case IDENT:
			case PARENTESIS_ABIERTO:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				{
				instruccion_simple();
				match(PUNTO_Y_COMA);
				}
				break;
			}
			case BEGIN:
			{
				bloque();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void acotado() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			guarda();
			cuerpo();
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void guarda() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(DESDE);
			expresion();
			match(ASIGNACION);
			expresion();
			{
			switch ( LA(1)) {
			case ATRAS:
			{
				match(ATRAS);
				break;
			}
			case HASTA:
			{
				match(HASTA);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			expresion();
			match(HACER);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_26);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void cuerpo() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case IDENT:
			case PARENTESIS_ABIERTO:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				{
				instruccion_simple();
				match(PUNTO_Y_COMA);
				}
				break;
			}
			case BEGIN:
			{
				bloque();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_17);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_1() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion_nivel_2();
			{
			_loop1665:
			do {
				if ((LA(1)==AND)) {
					match(AND);
					expresion_nivel_2();
				}
				else {
					break _loop1665;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_27);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_2() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case NOT:
			{
				match(NOT);
				expresion_nivel_2();
				break;
			}
			case IDENT:
			case PARENTESIS_ABIERTO:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				expresion_nivel_3();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_3() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion_nivel_4();
			{
			switch ( LA(1)) {
			case IGUAL:
			case MAYOR:
			case MAYOR_IGUAL:
			case MENOR:
			case MENOR_IGUAL:
			case DISTINTO:
			{
				{
				switch ( LA(1)) {
				case MAYOR:
				{
					match(MAYOR);
					break;
				}
				case MAYOR_IGUAL:
				{
					match(MAYOR_IGUAL);
					break;
				}
				case MENOR:
				{
					match(MENOR);
					break;
				}
				case MENOR_IGUAL:
				{
					match(MENOR_IGUAL);
					break;
				}
				case IGUAL:
				{
					match(IGUAL);
					break;
				}
				case DISTINTO:
				{
					match(DISTINTO);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				expresion_nivel_4();
				break;
			}
			case IDENT:
			case PUNTO_Y_COMA:
			case COMA:
			case PARENTESIS_ABIERTO:
			case PARENTESIS_CERRADO:
			case BEGIN:
			case ASIGNACION:
			case HACER:
			case ATRAS:
			case HASTA:
			case OR:
			case AND:
			case NOT:
			case MENOS:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			case CORCHETE_CERRADO:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_4() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion_nivel_5();
			{
			_loop1673:
			do {
				if ((LA(1)==MAS||LA(1)==MENOS) && (_tokenSet_29.member(LA(2)))) {
					{
					switch ( LA(1)) {
					case MAS:
					{
						match(MAS);
						break;
					}
					case MENOS:
					{
						match(MENOS);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					expresion_nivel_5();
				}
				else {
					break _loop1673;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_30);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_5() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion_nivel_6();
			{
			_loop1677:
			do {
				if (((LA(1) >= POR && LA(1) <= MOD))) {
					{
					switch ( LA(1)) {
					case POR:
					{
						match(POR);
						break;
					}
					case DIVISION:
					{
						match(DIVISION);
						break;
					}
					case DIV:
					{
						match(DIV);
						break;
					}
					case MOD:
					{
						match(MOD);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					expresion_nivel_6();
				}
				else {
					break _loop1677;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_31);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_6() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case MENOS:
			{
				match(MENOS);
				expresion_nivel_6();
				break;
			}
			case IDENT:
			case PARENTESIS_ABIERTO:
			case LIT_ENTERO:
			case LIT_REAL:
			case LIT_CAR:
			case CIERTO:
			case FALSO:
			case FRASE:
			{
				expresion_nivel_7();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_24);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void expresion_nivel_7() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case PARENTESIS_ABIERTO:
			{
				match(PARENTESIS_ABIERTO);
				expresion();
				match(PARENTESIS_CERRADO);
				break;
			}
			case LIT_ENTERO:
			{
				match(LIT_ENTERO);
				break;
			}
			case LIT_REAL:
			{
				match(LIT_REAL);
				break;
			}
			case LIT_CAR:
			{
				match(LIT_CAR);
				break;
			}
			case CIERTO:
			{
				match(CIERTO);
				break;
			}
			case FALSO:
			{
				match(FALSO);
				break;
			}
			case FRASE:
			{
				match(FRASE);
				break;
			}
			default:
				boolean synPredMatched1681 = false;
				if (((LA(1)==IDENT) && (LA(2)==PARENTESIS_ABIERTO||LA(2)==CORCHETE_ABIERTO||LA(2)==PUNTO))) {
					int _m1681 = mark();
					synPredMatched1681 = true;
					inputState.guessing++;
					try {
						{
						acceso();
						match(PARENTESIS_ABIERTO);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched1681 = false;
					}
					rewind(_m1681);
inputState.guessing--;
				}
				if ( synPredMatched1681 ) {
					llamada_metodo();
				}
				else {
					boolean synPredMatched1683 = false;
					if (((LA(1)==IDENT) && (LA(2)==CORCHETE_ABIERTO))) {
						int _m1683 = mark();
						synPredMatched1683 = true;
						inputState.guessing++;
						try {
							{
							acceso();
							match(CORCHETE_ABIERTO);
							}
						}
						catch (RecognitionException pe) {
							synPredMatched1683 = false;
						}
						rewind(_m1683);
inputState.guessing--;
					}
					if ( synPredMatched1683 ) {
						acceso_array();
					}
					else if ((LA(1)==IDENT) && (_tokenSet_32.member(LA(2)))) {
						acceso();
					}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				}}
			}
			catch (RecognitionException ex) {
				if (inputState.guessing==0) {
					reportError(ex);
					recover(ex,_tokenSet_24);
				} else {
				  throw ex;
				}
			}
		}
		
	public final void acceso_array() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			acceso_simple();
			match(CORCHETE_ABIERTO);
			lista_expresiones_nv();
			match(CORCHETE_CERRADO);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_24);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void acceso_simple() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(IDENT);
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_32);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void lista_expresiones_nv() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			expresion();
			{
			_loop1693:
			do {
				if ((LA(1)==COMA)) {
					match(COMA);
					expresion();
				}
				else {
					break _loop1693;
				}
				
			} while (true);
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_33);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void tipo_predefinido_simple() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case ENTERO:
			{
				match(ENTERO);
				break;
			}
			case REAL:
			{
				match(REAL);
				break;
			}
			case BOOLEANO:
			{
				match(BOOLEANO);
				break;
			}
			case CARACTER:
			{
				match(CARACTER);
				break;
			}
			case MENOS:
			case LIT_CAR:
			case RANGO_NUM:
			{
				rango();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_12);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void tipo_predefinido_compuesto() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case ARRAY:
			{
				array();
				break;
			}
			case CADENA:
			{
				cadena();
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_12);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void rango() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			switch ( LA(1)) {
			case MENOS:
			case RANGO_NUM:
			{
				{
				switch ( LA(1)) {
				case MENOS:
				{
					match(MENOS);
					break;
				}
				case RANGO_NUM:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				match(RANGO_NUM);
				break;
			}
			case LIT_CAR:
			{
				match(LIT_CAR);
				match(DOBLEPUNTO);
				match(LIT_CAR);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_34);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void array() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			match(ARRAY);
			match(CORCHETE_ABIERTO);
			lista_expresiones_array();
			match(CORCHETE_CERRADO);
			match(OF);
			{
			switch ( LA(1)) {
			case MENOS:
			case LIT_CAR:
			case ENTERO:
			case REAL:
			case BOOLEANO:
			case CARACTER:
			case RANGO_NUM:
			{
				tipo_predefinido_simple();
				break;
			}
			case IDENT:
			{
				match(IDENT);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_12);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void cadena() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			if ((LA(1)==CADENA) && (LA(2)==CORCHETE_ABIERTO)) {
				match(CADENA);
				match(CORCHETE_ABIERTO);
				expresion();
				match(CORCHETE_CERRADO);
			}
			else if ((LA(1)==CADENA) && (LA(2)==IDENT)) {
				match(CADENA);
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_12);
			} else {
			  throw ex;
			}
		}
	}
	
	public final void lista_expresiones_array() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			boolean synPredMatched1704 = false;
			if (((_tokenSet_23.member(LA(1))) && (_tokenSet_35.member(LA(2))))) {
				int _m1704 = mark();
				synPredMatched1704 = true;
				inputState.guessing++;
				try {
					{
					expresion();
					}
				}
				catch (RecognitionException pe) {
					synPredMatched1704 = false;
				}
				rewind(_m1704);
inputState.guessing--;
			}
			if ( synPredMatched1704 ) {
				expresion();
				{
				_loop1706:
				do {
					if ((LA(1)==COMA)) {
						match(COMA);
						segundo_elemento();
					}
					else {
						break _loop1706;
					}
					
				} while (true);
				}
			}
			else {
				boolean synPredMatched1708 = false;
				if (((LA(1)==MENOS||LA(1)==LIT_CAR||LA(1)==RANGO_NUM) && (_tokenSet_36.member(LA(2))))) {
					int _m1708 = mark();
					synPredMatched1708 = true;
					inputState.guessing++;
					try {
						{
						rango();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched1708 = false;
					}
					rewind(_m1708);
inputState.guessing--;
				}
				if ( synPredMatched1708 ) {
					rango();
					{
					_loop1710:
					do {
						if ((LA(1)==COMA)) {
							match(COMA);
							segundo_elemento();
						}
						else {
							break _loop1710;
						}
						
					} while (true);
					}
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
			}
			catch (RecognitionException ex) {
				if (inputState.guessing==0) {
					reportError(ex);
					recover(ex,_tokenSet_33);
				} else {
				  throw ex;
				}
			}
		}
		
	public final void segundo_elemento() throws RecognitionException, TokenStreamException {
		
		
		try {      // for error handling
			boolean synPredMatched1713 = false;
			if (((_tokenSet_23.member(LA(1))) && (_tokenSet_35.member(LA(2))))) {
				int _m1713 = mark();
				synPredMatched1713 = true;
				inputState.guessing++;
				try {
					{
					expresion();
					}
				}
				catch (RecognitionException pe) {
					synPredMatched1713 = false;
				}
				rewind(_m1713);
inputState.guessing--;
			}
			if ( synPredMatched1713 ) {
				expresion();
			}
			else {
				boolean synPredMatched1715 = false;
				if (((LA(1)==MENOS||LA(1)==LIT_CAR||LA(1)==RANGO_NUM) && (_tokenSet_36.member(LA(2))))) {
					int _m1715 = mark();
					synPredMatched1715 = true;
					inputState.guessing++;
					try {
						{
						rango();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched1715 = false;
					}
					rewind(_m1715);
inputState.guessing--;
				}
				if ( synPredMatched1715 ) {
					rango();
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
			}
			catch (RecognitionException ex) {
				if (inputState.guessing==0) {
					reportError(ex);
					recover(ex,_tokenSet_37);
				} else {
				  throw ex;
				}
			}
		}
		
		
		public static final String[] _tokenNames = {
			"<0>",
			"EOF",
			"<2>",
			"NULL_TREE_LOOKAHEAD",
			"CONST",
			"IDENT",
			"IGUAL",
			"PUNTO_Y_COMA",
			"TYPE",
			"REGISTRO",
			"END",
			"VAR",
			"COMA",
			"FUNCION",
			"PARENTESIS_ABIERTO",
			"PARENTESIS_CERRADO",
			"BEGIN",
			"ASIGNACION",
			"SI",
			"SINO",
			"MIENTRAS",
			"HACER",
			"DESDE",
			"ATRAS",
			"HASTA",
			"OR",
			"AND",
			"NOT",
			"MAYOR",
			"MAYOR_IGUAL",
			"MENOR",
			"MENOR_IGUAL",
			"DISTINTO",
			"MAS",
			"MENOS",
			"POR",
			"DIVISION",
			"DIV",
			"MOD",
			"CORCHETE_ABIERTO",
			"LIT_ENTERO",
			"LIT_REAL",
			"LIT_CAR",
			"CIERTO",
			"FALSO",
			"FRASE",
			"CORCHETE_CERRADO",
			"PUNTO",
			"ENTERO",
			"REAL",
			"BOOLEANO",
			"CARACTER",
			"RANGO_NUM",
			"DOBLEPUNTO",
			"CADENA",
			"ARRAY",
			"OF"
		};
		
		private static final long[] mk_tokenSet_0() {
			long[] data = { 2L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
		private static final long[] mk_tokenSet_1() {
			long[] data = { 65536L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
		private static final long[] mk_tokenSet_2() {
			long[] data = { 62838206358634528L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
		private static final long[] mk_tokenSet_3() {
			long[] data = { 67840L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
		private static final long[] mk_tokenSet_4() {
			long[] data = { 67584L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
		private static final long[] mk_tokenSet_5() {
			long[] data = { 62773335032864800L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
		private static final long[] mk_tokenSet_6() {
			long[] data = { 67872L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
		private static final long[] mk_tokenSet_7() {
			long[] data = { 139655318327456L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
		private static final long[] mk_tokenSet_8() {
			long[] data = { 67616L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
		private static final long[] mk_tokenSet_9() {
			long[] data = { 62773335032856608L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
		private static final long[] mk_tokenSet_10() {
			long[] data = { 1024L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
		private static final long[] mk_tokenSet_11() {
			long[] data = { 62773335032857632L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
		private static final long[] mk_tokenSet_12() {
			long[] data = { 32L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
		private static final long[] mk_tokenSet_13() {
			long[] data = { 62773335032930336L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
		private static final long[] mk_tokenSet_14() {
			long[] data = { 128L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
		private static final long[] mk_tokenSet_15() {
			long[] data = { 4098L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
		private static final long[] mk_tokenSet_16() {
			long[] data = { 13511348637925408L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
		private static final long[] mk_tokenSet_17() {
			long[] data = { 62838206358635552L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
		private static final long[] mk_tokenSet_18() {
			long[] data = { 32768L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
		private static final long[] mk_tokenSet_19() {
			long[] data = { 36864L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
		private static final long[] mk_tokenSet_20() {
			long[] data = { 69286552158240L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
		private static final long[] mk_tokenSet_21() {
			long[] data = { 211106199126112L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
		private static final long[] mk_tokenSet_22() {
			long[] data = { 4224L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
		private static final long[] mk_tokenSet_23() {
			long[] data = { 69286546653216L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
		private static final long[] mk_tokenSet_24() {
			long[] data = { 140187726500064L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
		private static final long[] mk_tokenSet_25() {
			long[] data = { 62838206359159840L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
		private static final long[] mk_tokenSet_26() {
			long[] data = { 69286546718752L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
		private static final long[] mk_tokenSet_27() {
			long[] data = { 139655351881888L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
		private static final long[] mk_tokenSet_28() {
			long[] data = { 139655418990752L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
		private static final long[] mk_tokenSet_29() {
			long[] data = { 69286412435488L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
		private static final long[] mk_tokenSet_30() {
			long[] data = { 139663740489952L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
		private static final long[] mk_tokenSet_31() {
			long[] data = { 139672330424544L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
		private static final long[] mk_tokenSet_32() {
			long[] data = { 281474970669280L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
		private static final long[] mk_tokenSet_33() {
			long[] data = { 70368744177664L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
		private static final long[] mk_tokenSet_34() {
			long[] data = { 70368744181792L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
		private static final long[] mk_tokenSet_35() {
			long[] data = { 281474943176800L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
		private static final long[] mk_tokenSet_36() {
			long[] data = { 13581167626293248L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
		private static final long[] mk_tokenSet_37() {
			long[] data = { 70368744181760L, 0L};
			return data;
		}
		public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
		
		}
